home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1993…ch: Other People's Memory / ADC Developer CD (1993-03) (''Other People's Memory'')_iso / Dev.CD Mar 93.iso / Development Platforms / Apple II / Essentials / MPW IIGS Interfaces / PIIGSIncludes / GSOS.p < prev    next >
Encoding:
Text File  |  1992-02-26  |  26.7 KB  |  708 lines  |  [TEXT/MPS ]
  1. {********************************************
  2. ; File: GSOS.p
  3. ;
  4. ;
  5. ; Copyright Apple Computer, Inc. 1986-91
  6. ; All Rights Reserved
  7. ;
  8. ********************************************}
  9.  
  10. unit gsos;
  11.  
  12.   interface
  13.  
  14.     uses types;
  15.  
  16.     const
  17.  
  18. {
  19.     Read/Write enable bit Codes
  20.     for CreateRec/OpenRec access and requestAccess fields
  21. }
  22.  
  23.       readenableallowwrite = $0000;
  24.       readenable = $0001;
  25.       writeenable = $0002;
  26.       readwriteenable = $0003;
  27.       fileinvisible = $0004; { Invisible bit }
  28.       backupneeded = $0020; { backup needed bit: CreateRec/ OpenRec access
  29.                              field. (Must be 0 in requestAccess field ) }
  30.       renameenable = $0040; { rename enable bit: CreateRec/ OpenRec access and
  31.                              requestAccess fields }
  32.       destroyenable = $0080; { destroy enable bit: CreateRec/ OpenRec access and
  33.                               requestAccess fields }
  34.       startplus = $0000; { base -> setMark = displacement }
  35.       eofminus = $0001; { base -> setMark = eof - displacement }
  36.       markplus = $0002; { base -> setMark = mark + displacement }
  37.       markminus = $0003; { base -> setMark = mark - displacement }
  38.  
  39.       { cachePriority Codes }
  40.       cacheoff = $0000; { do not cache blocks invloved in this read }
  41.       cacheon = $0001; { cache blocks invloved in this read if possible }
  42.  
  43.       { Error Codes }
  44.       badsystemcall = $0001; { bad system call number }
  45.       invalidpcount = $0004; { invalid parameter count }
  46.       gsosactive = $0007; { GS/OS already active }
  47.       {$IFC UNDEFINED devNotFound } { device not found }
  48.       devnotfound = $0010;
  49.       {$SETC devNotFound := 0}
  50.       {$ENDC}
  51.       invaliddevnum = $0011; { invalid device number }
  52.       drvrbadreq = $20; { bad request or command }
  53.       drvrbadcode = $0021; { bad control or status code }
  54.       drvrbadparm = $0022; { bad call parameter }
  55.       drvrnotopen = $0023; { character device not open }
  56.       drvrprioropen = $0024; { character device already open }
  57.       irqtablefull = $0025; { interrupt table full }
  58.       drvrnoresrc = $0026; { resources not available }
  59.       drvrioerror = $0027; { I/O error }
  60.       drvrnodevice = $0028; { device not connected }
  61.       drvrbusy = $0029; { call aborted; driver is busy }
  62.       drvrwrtprot = $002B; { device is write protected }
  63.       drvrbadcount = $002C; { invalid byte count }
  64.       drvrbadblock = $002D; { invalid block address }
  65.       drvrdiskswitch = $002E; { disk has been switched }
  66.       drvroffline = $002F; { device off line/ no media present }
  67.       badpathsyntax = $0040; { invalid pathname syntax }
  68.       toomanyfilesopen = $0042; { too many files open on server volume }
  69.       invalidrefnum = $0043; { invalid reference number }
  70.       {$IFC UNDEFINED pathNotFound } { subdirectory does not exist }
  71.       pathnotfound = $44;
  72.       {$SETC pathNotFound := 0}
  73.       {$ENDC}
  74.       volnotfound = $0045; { volume not found }
  75.       {$IFC UNDEFINED fileNotFound } { file not found }
  76.       filenotfound = $0046;
  77.       {$SETC fileNotFound := 0}
  78.       {$ENDC}
  79.       duppathname = $0047; { create or rename with existing name }
  80.       volumefull = $0048; { volume full error }
  81.       voldirfull = $0049; { volume directory full }
  82.       badfileformat = $004A; { version error (incompatible file format) }
  83.       {$IFC UNDEFINED badStoreType } { unsupported (or incorrect) storage type }
  84.       badstoretype = $004B;
  85.       {$SETC badStoreType := 0}
  86.       {$ENDC}
  87.       {$IFC UNDEFINED eofEncountered } { end-of-file encountered }
  88.       eofencountered = $004C;
  89.       {$SETC eofEncountered := 0}
  90.       {$ENDC}
  91.       outofrange = $004D; { position out of range }
  92.       invalidaccess = $004E; { access not allowed }
  93.       bufftoosmall = $004F; { buffer too small }
  94.       filebusy = $0050; { file is already open }
  95.       direrror = $0051; { directory error }
  96.       unknownvol = $0052; { unknown volume type }
  97.       {$IFC UNDEFINED paramRangeErr } { parameter out of range }
  98.       paramrangeerr = $0053;
  99.       {$SETC paramRangeErr := 0}
  100.       {$ENDC}
  101.       outofmem = $0054; { out of memory }
  102.       dupvolume = $0057; { duplicate volume name }
  103.       notblockdev = $0058; { not a block device }
  104.       {$IFC UNDEFINED invalidLevel } { specifield level outside legal range }
  105.       invalidlevel = $0059;
  106.       {$SETC invalidLevel := 0}
  107.       {$ENDC}
  108.       damagedbitmap = $005A; { block number too large }
  109.       badpathnames = $005B; { invalid pathnames for ChangePath }
  110.       notsystemfile = $005C; { not an executable file }
  111.       osunsupported = $005D; { Operating System not supported }
  112.       {$IFC UNDEFINED stackOverflow } { too many applications on stack }
  113.       stackoverflow = $005F;
  114.       {$SETC stackOverflow := 0}
  115.       {$ENDC}
  116.       dataunavail = $0060; { Data unavailable }
  117.       endofdir = $0061; { end of directory has been reached }
  118.       invalidclass = $0062; { invalid FST call class }
  119.       resforknotfound = $0063; { file does not contain required resource }
  120.       invalidfstid = $0064; { error - FST ID is invalid }
  121.       invalidFSTop = $0065; { invalid FST operation }
  122.       fstCaution = $0066; { FST handled call, but result is wierd }
  123.       devnameerr = $0067; { device exists with same name as replacement name }
  124.       devListFull = $0068; { device list is full }
  125.       supListFull = $0069; { supervisor list is full }
  126.       fstError = $006a; { generic FST error
  127.       resexistserr = $0070; { cannot expand file, resource already exists }
  128.       resadderr = $0071; { cannot add resource fork to this type file }
  129.       networkError = $0088; { generic network error }
  130.  
  131.       { fileSys IDs }
  132.       prodosfsid = $0001; { ProDOS/SOS }
  133.       dos33fsid = $0002; { DOS 3.3 }
  134.       dos32fsid = $0003; { DOS 3.2 }
  135.       dos31fsid = $0003; { DOS 3.1 }
  136.       appleiipascalfsid = $0004; { Apple II Pascal }
  137.       mfsfsid = $0005; { Macintosh (flat file system) }
  138.       hfsfsid = $0006; { Macintosh (hierarchical file system) }
  139.       lisafsid = $0007; { Lisa file system }
  140.       applecpmfsid = $0008; { Apple CP/M }
  141.       charfstfsid = $0009; { Character FST }
  142.       msdosfsid = $000A; { MS/DOS }
  143.       highsierrafsid = $000B; { High Sierra }
  144.       iso9660fsid = $000C; { ISO 9660 }
  145.       applesharefsid = $000D; { ISO 9660 }
  146.  
  147.       { FSTInfo.attributes Codes }
  148.       characterfst = $4000; { character FST }
  149.       ucfst = $8000; { SCM should upper case pathnames before passing them to
  150.                       the FST }
  151.  
  152.       { QuitRec.flags Codes }
  153.       onstack = $8000; { place state information about quitting program on the
  154.                         quit return stack }
  155.       restartable = $4000; { the quitting program is capable of being restarted
  156.                             from its dormant memory }
  157.  
  158.       { storageType Codes }
  159.       seedling = $0001; { standard file with seedling structure }
  160.       standardfile = $0001; { standard file type (no resource fork) }
  161.       sapling = $0002; { standard file with sapling structure }
  162.       tree = $0003; { standard file with tree structure }
  163.       pascalregion = $0004; { UCSD Pascal region on a partitioned disk }
  164.       extendedfile = $0005; { extended file type (with resource fork) }
  165.       directoryfile = $000D; { volume directory or subdirectory file }
  166.  
  167.       { version Codes }
  168.       minorrelnummask = $00FF; { minor release number }
  169.       majorrelnummask = $7F00; { major release number }
  170.       finalrelnummask = $8000; { final release number }
  171.  
  172.       { Other Constants }
  173.       isfileextended = $8000; { GetDirEntryGS }
  174.  
  175.       { DControl Codes }
  176.       resetdevice = $0000;
  177.       formatdevice = $0001;
  178.       eject = $0002;
  179.       setconfigparameters = $0003;
  180.       setwaitstatus = $0004;
  181.       setformatoptions = $0005;
  182.       assignpartitionowner = $0006;
  183.       armsignal = $0007;
  184.       disarmsignal = $0008;
  185.       setpartitionmap = $0009;
  186.  
  187.     type
  188.       gsstring255hndl = ^gsstring255ptr;
  189.       gsstring255ptr = ^gsstring255;
  190.       gsstring255 = record
  191.                       length: integer; { Number of Chars in text field }
  192.                       text: packed array [1..255] of char;
  193.                     end;
  194.       gsstring255hndlptr = ^gsstring255hndl;
  195.  
  196.       gsstring32hndl = ^gsstring32ptr;
  197.       gsstring32ptr = ^gsstring32;
  198.       gsstring32 = record
  199.                      length: integer; { Number of characters in text field }
  200.                      text: packed array [1..32] of char;
  201.                    end;
  202.       resultbuf255hndl = ^resultbuf255ptr;
  203.       resultbuf255ptr = ^resultbuf255;
  204.       resultbuf255 = record
  205.                        bufsize: integer;
  206.                        bufstring: gsstring255;
  207.                      end;
  208.       resultbuf255hndlptr = ^resultbuf255hndl;
  209.  
  210.       resultbuf32hndl = ^resultbuf32ptr;
  211.       resultbuf32ptr = ^resultbuf32;
  212.       resultbuf32 = record
  213.                       bufsize: integer;
  214.                       bufstring: gsstring32;
  215.                     end;
  216.       changepathrecptrgs = ^changepathrecgs;
  217.       changepathrecgs = record
  218.                           pcount: integer;
  219.                           pathname: gsstring255ptr;
  220.                           newpathname: gsstring255ptr;
  221.                           flags : Integer;
  222.                         end;
  223.       createrecptrgs = ^createrecgs;
  224.       createrecgs = record
  225.                       pcount: integer;
  226.                       pathname: gsstring255ptr;
  227.                       access: integer;
  228.                       filetype: integer;
  229.                       auxtype: longint;
  230.                       storagetype: integer;
  231.                       eof: longint;
  232.                       resourceeof: longint;
  233.                     end;
  234.       daccessrecptrgs = ^daccessrecgs;
  235.       daccessrecgs = record
  236.                        pcount: integer;
  237.                        devnum: integer;
  238.                        code: integer;
  239.                        list: ptr;
  240.                        requestcount: longint;
  241.                        transfercount: longint;
  242.                      end;
  243.       devnumrecptrgs = ^devnumrecgs;
  244.       devnumrecgs = record
  245.                       pcount: integer;
  246.                       devname: gsstring32ptr;
  247.                       devnum: integer;
  248.                     end;
  249.       dinforecptrgs = ^dinforecgs;
  250.       dinforecgs = record
  251.                      pcount: integer; { minimum = 2 }
  252.                      devnum: integer;
  253.                      devname: resultbuf32ptr;
  254.                      characteristics: integer;
  255.                      totalblocks: longint;
  256.                      slotnum: integer;
  257.                      unitnum: integer;
  258.                      version: integer;
  259.                      deviceid: integer;
  260.                      headlink: integer;
  261.                      forwardlink: integer;
  262.                      extendeddibptr: ptr;
  263.                    end;
  264.       diorecptrgs = ^diorecgs;
  265.       diorecgs = record
  266.                    pcount: integer;
  267.                    devnum: integer;
  268.                    buffer: ptr;
  269.                    requestcount: longint;
  270.                    startingblock: longint;
  271.                    blocksize: integer;
  272.                    transfercount: longint;
  273.                  end;
  274.       direntryrecptrgs = ^direntryrecgs;
  275.       direntryrecgs = record
  276.                         pcount: integer;
  277.                         refnum: integer;
  278.                         flags: integer;
  279.                         base: integer;
  280.                         displacement: integer;
  281.                         name: resultbuf255ptr;
  282.                         entrynum: integer;
  283.                         filetype: integer;
  284.                         eof: longint;
  285.                         blockcount: longint;
  286.                         createdatetime: timerec;
  287.                         moddatetime: timerec;
  288.                         access: integer;
  289.                         auxtype: longint;
  290.                         filesysid: integer;
  291.                         optionlist: resultbuf255ptr;
  292.                         resourceeof: longint;
  293.                         resourceblocks: longint;
  294.                       end;
  295.       drenamerecgsptr = ^drenamerecgs;
  296.       drenamerecgs = record
  297.                        pcount: integer;
  298.                        devnum: integer;
  299.                        strptr: gsstring32ptr;
  300.                      end;
  301.       expandpathrecptrgs = ^expandpathrecgs;
  302.       expandpathrecgs = record
  303.                           pcount: integer;
  304.                           inputpath: gsstring255ptr;
  305.                           outputpath: resultbuf255ptr;
  306.                           flags: integer;
  307.                         end;
  308.       fileinforecptrgs = ^fileinforecgs;
  309.       fileinforecgs = record
  310.                         pcount: integer;
  311.                         pathname: gsstring255ptr;
  312.                         access: integer;
  313.                         filetype: integer;
  314.                         auxtype: longint;
  315.                         storagetype: integer; { must be 0 for SetFileInfo }
  316.                         createdatetime: timerec;
  317.                         moddatetime: timerec;
  318.                         optionlist: resultbuf255ptr;
  319.                         eof: longint;
  320.                         blocksused: longint; { must be 0 for SetFileInfo }
  321.                         resourceeof: longint; { must be 0 for SetFileInfo }
  322.                         resourceblocks: longint; { must be 0 for SetFileInfo }
  323.                       end;
  324.       formatrecptrgs = ^formatrecgs;
  325.       formatrecgs = record
  326.                       pcount: integer;
  327.                       devname: gsstring32ptr; { device name pointer }
  328.                       volname: gsstring32ptr; { volume name pointer }
  329.                       filesysid: integer; { file system ID }
  330.                       reqfilesysid: integer; { in; }
  331.                       flags: integer;
  332.                       realvolname: resultbuf255ptr;
  333.                     end;
  334.       fstinforecptrgs = ^fstinforecgs;
  335.       fstinforecgs = record
  336.                        pcount: integer;
  337.                        fstnum: integer;
  338.                        filesysid: integer;
  339.                        fstname: resultbuf255ptr;
  340.                        version: integer;
  341.                        attributes: integer;
  342.                        blocksize: integer;
  343.                        maxvolsize: longint;
  344.                        maxfilesize: longint;
  345.                      end;
  346.       interruptrecptrgs = ^interruptrecgs;
  347.       interruptrecgs = record
  348.                          pcount: integer;
  349.                          intnum: integer;
  350.                          vrn: integer; { used only by BindInt }
  351.                          intcode: procptr; { used only by BindInt }
  352.                        end;
  353.       iorecptrgs = ^iorecgs;
  354.       iorecgs = record
  355.                   pcount: integer;
  356.                   refnum: integer;
  357.                   databuffer: ptr;
  358.                   requestcount: longint;
  359.                   transfercount: longint;
  360.                   cachepriority: integer;
  361.                 end;
  362.       judgenamerecptrgs = ^judgenamerecgs;
  363.       judgenamerecgs = record
  364.                           pcount: integer;
  365.                         filesysid: integer;
  366.                         nametype: integer;
  367.                         syntax:    stringptr;
  368.                         maxlen: integer;
  369.                         name: resultbuf255ptr;
  370.                         nameflags: integer;
  371.                     end;
  372.       levelrecptrgs = ^levelrecgs;
  373.       levelrecgs = record
  374.                      pcount: integer;
  375.                      level: integer;
  376.                      levelmode: integer;
  377.                    end;
  378.       namerecptrgs = ^namerecgs;
  379.       namerecgs = record
  380.                     pcount: integer;
  381.                     pathname: gsstring255ptr; { full pathname or a filename
  382.                                                depending on call }
  383.                   end;
  384.       notifyprocrecgsptr = ^notifyprocrecgs;
  385.       notifyprocrecgs = record
  386.                           pcount: integer;
  387.                           procpointer: procptr;
  388.                         end;
  389.       getnamerecptrgs = ^getnamerecgs;
  390.       getnamerecgs = record
  391.                        pcount: integer;
  392.                        databuffer: resultbuf255ptr; { full pathname or a
  393.                                                      filename depending on call }
  394.                        userid: integer;
  395.                      end;
  396.       newlinerecptrgs = ^newlinerecgs;
  397.       newlinerecgs = record
  398.                        pcount: integer;
  399.                        refnum: integer;
  400.                        enablemask: integer;
  401.                        numchars: integer;
  402.                        newlinetable: ptr;
  403.                      end;
  404.       openrecptrgs = ^openrecgs;
  405.       openrecgs = record
  406.                     pcount: integer;
  407.                     refnum: integer;
  408.                     pathname: gsstring255ptr;
  409.                     requestaccess: integer;
  410.                     resourcenumber: integer; { For extended files:
  411.                                               dataFork/resourceFork }
  412.                     access: integer; { Value of file's access attribute }
  413.                     filetype: integer; { Value of file's fileType attribute }
  414.                     auxtype: longint;
  415.                     storagetype: integer;
  416.                     createdatetime: timerec;
  417.                     moddatetime: timerec;
  418.                     optionlist: resultbuf255ptr;
  419.                     eof: longint;
  420.                     blocksused: longint;
  421.                     resourceeof: longint;
  422.                     resourceblocks: longint;
  423.                   end;
  424.       osshutdownrecptrgs = ^osshutdownrecgs;
  425.       osshutdownrecgs = record
  426.                           pcount: integer;
  427.                           shutdownflag: integer;
  428.                         end;
  429.       positionrecptrgs = ^positionrecgs;
  430.       positionrecgs = record
  431.                         pcount: integer;
  432.                         refnum: integer;
  433.                         position: longint;
  434.                       end;
  435.       eofrecptrgs = ^eofrecgs;
  436.       eofrecgs = record
  437.                    pcount: integer;
  438.                    refnum: integer;
  439.                    eof: longint;
  440.                  end;
  441.       prefixrecptrgs = ^prefixrecgs;
  442.       prefixrecgs = record
  443.                       pcount: integer;
  444.                       prefixnum: integer;
  445.                       case integer of
  446.                         0:
  447.                           (getprefix: resultbuf255ptr; );
  448.                         1:
  449.                           (setprefix: gsstring255ptr; );
  450.                     end;
  451.       quitrecptrgs = ^quitrecgs;
  452.       quitrecgs = record
  453.                     pcount: integer;
  454.                     pathname: gsstring255ptr; { pathname of next app to run }
  455.                     flags: integer;
  456.                   end;
  457.       refnumrecptrgs = ^refnumrecgs;
  458.       refnumrecgs = record
  459.                       pcount: integer;
  460.                       refnum: integer;
  461.                     end;
  462.       getrefnumrecptrgs = ^getrefnumrecgs;
  463.       getrefnumrecgs = record
  464.                          pcount: integer;
  465.                          pathname: gsstring255ptr;
  466.                          refnum: integer;
  467.                          access: integer;
  468.                          resnum: integer;
  469.                          casesense: boolean;
  470.                          displacement: integer;
  471.                        end;
  472.       stdrefnumrecgsptr = ^stdrefnumrecgs;
  473.       stdrefnumrecgs = record
  474.                          pcount: integer;
  475.                          prefixnum: integer;
  476.                          refnum: integer;
  477.                        end;
  478.       sessionstatusrecptrgs = ^sessionstatusrecgs;
  479.       sessionstatusrecgs = record
  480.                              pcount: integer; { in: min = 1 }
  481.                              status: integer; { out: }
  482.                            end;
  483.       setpositionrecptrgs = ^setpositionrecgs;
  484.       setpositionrecgs = record
  485.                            pcount: integer;
  486.                            refnum: integer;
  487.                            base: integer;
  488.                            displacement: longint;
  489.                          end;
  490.       sysprefsrecptrgs = ^sysprefsrecgs;
  491.       sysprefsrecgs = record
  492.                         pcount: integer;
  493.                         preferences: integer;
  494.                       end;
  495.       versionrecptrgs = ^versionrecgs;
  496.       versionrecgs = record
  497.                        pcount: integer;
  498.                        version: integer;
  499.                      end;
  500.       volumerecptrgs = ^volumerecgs;
  501.       volumerecgs = record
  502.                       pcount: integer;
  503.                       devname: gsstring32ptr;
  504.                       volname: resultbuf255ptr;
  505.                       totalblocks: longint;
  506.                       freeblocks: longint;
  507.                       filesysid: integer;
  508.                       blocksize: integer;
  509.                       characteristics: integer;
  510.                       deviceid: integer;
  511.                     end;
  512.       refinforecgsptr = ^refinforecgs;
  513.       refinforecgs = record
  514.                        pcount: integer;
  515.                        refnum: integer;
  516.                        access: integer;
  517.                        pathname: resultbuf255ptr;
  518.                        resourcenumber: integer;
  519.                        level: integer;
  520.                      end;
  521.       filerecgs = record
  522.                     case integer of
  523.                       0:
  524.                         (derec: direntryrecgs);
  525.                       1:
  526.                         (iorec: iorecgs);
  527.                       2:
  528.                         (nlrec: newlinerecgs);
  529.                       3:
  530.                         (oprec: openrecgs);
  531.                       4:
  532.                         (porec: positionrecgs);
  533.                       5:
  534.                         (eorec: eofrecgs);
  535.                       6:
  536.                         (rnrec: refnumrecgs);
  537.                       7:
  538.                         (sprec: setpositionrecgs);
  539.                   end;
  540.  
  541.     procedure addnotifyprocgs(var pblockptr: notifyprocrecgsptr);
  542.       inline $2034F4, $E100B022, $8F, '_toolErr';
  543.  
  544.     procedure beginsessiongs(var pblockptr: sessionstatusrecgs);
  545.       inline $201DF4, $E100B022, $8F, '_toolErr';
  546.  
  547.     procedure bindintgs(var pblockptr: interruptrecgs);
  548.       inline $2031F4, $E100B022, $8F, '_toolErr';
  549.  
  550.     procedure changepathgs(var pblockptr: changepathrecgs);
  551.       inline $2004F4, $E100B022, $8F, '_toolErr';
  552.  
  553.     procedure clearbackupbitgs(var pblockptr: namerecgs);
  554.       inline $200BF4, $E100B022, $8F, '_toolErr';
  555.  
  556.     procedure closegs(var pblockptr: refnumrecgs);
  557.       inline $2014F4, $E100B022, $8F, '_toolErr';
  558.  
  559.     procedure creategs(var pblockptr: createrecgs);
  560.       inline $2001F4, $E100B022, $8F, '_toolErr';
  561.  
  562.     procedure dcontrolgs(var pblockptr: daccessrecgs);
  563.       inline $202EF4, $E100B022, $8F, '_toolErr';
  564.  
  565.     procedure delnotifyprocgs(var pblockptr: notifyprocrecgsptr);
  566.       inline $2035F4, $E100B022, $8F, '_toolErr';
  567.  
  568.     procedure destroygs(var pblockptr: namerecgs);
  569.       inline $2002F4, $E100B022, $8F, '_toolErr';
  570.  
  571.     procedure dinfogs(var pblockptr: dinforecgs);
  572.       inline $202CF4, $E100B022, $8F, '_toolErr';
  573.  
  574.     procedure dreadgs(var pblockptr: diorecgs);
  575.       inline $202FF4, $E100B022, $8F, '_toolErr';
  576.  
  577.     procedure drenamegs(var pblockptr: drenamerecgs);
  578.       inline $2036F4, $E100B022, $8F, '_toolErr';
  579.  
  580.     procedure dstatusgs(var pblockptr: daccessrecgs);
  581.       inline $202DF4, $E100B022, $8F, '_toolErr';
  582.  
  583.     procedure dwritegs(var pblockptr: diorecgs);
  584.       inline $2030F4, $E100B022, $8F, '_toolErr';
  585.  
  586.     procedure endsessiongs(var pblockptr: sessionstatusrecgs);
  587.       inline $201EF4, $E100B022, $8F, '_toolErr';
  588.  
  589.     procedure erasediskgs(var pblockptr: formatrecgs);
  590.       inline $2025F4, $E100B022, $8F, '_toolErr';
  591.  
  592.     procedure expandpathgs(var pblockptr: expandpathrecgs);
  593.       inline $200EF4, $E100B022, $8F, '_toolErr';
  594.  
  595.     procedure flushgs(var pblockptr: refnumrecgs);
  596.       inline $2015F4, $E100B022, $8F, '_toolErr';
  597.  
  598.     procedure formatgs(var pblockptr: formatrecgs);
  599.       inline $2024F4, $E100B022, $8F, '_toolErr';
  600.  
  601.     procedure fstspecific(pblockptr: ptr);
  602.       inline $2033F4, $E100B022, $8F, '_toolErr';
  603.  
  604.     procedure getbootvolgs(var pblockptr: getnamerecgs);
  605.       inline $2028F4, $E100B022, $8F, '_toolErr';
  606.  
  607.     procedure getdevnumbergs(var pblockptr: devnumrecgs);
  608.       inline $2020F4, $E100B022, $8F, '_toolErr';
  609.  
  610.     procedure getdirentrygs(var pblockptr: direntryrecgs);
  611.       inline $201CF4, $E100B022, $8F, '_toolErr';
  612.  
  613.     procedure geteofgs(var pblockptr: eofrecgs);
  614.       inline $2019F4, $E100B022, $8F, '_toolErr';
  615.  
  616.     procedure getfileinfogs(var pblockptr: fileinforecgs);
  617.       inline $2006F4, $E100B022, $8F, '_toolErr';
  618.  
  619.     procedure getfstinfogs(var pblockptr: fstinforecgs);
  620.       inline $202BF4, $E100B022, $8F, '_toolErr';
  621.  
  622.     procedure getlevelgs(var pblockptr: levelrecgs);
  623.       inline $201BF4, $E100B022, $8F, '_toolErr';
  624.  
  625.     procedure getmarkgs(var pblockptr: positionrecgs);
  626.       inline $2017F4, $E100B022, $8F, '_toolErr';
  627.  
  628.     procedure getnamegs(var pblockptr: getnamerecgs);
  629.       inline $2027F4, $E100B022, $8F, '_toolErr';
  630.  
  631.     procedure getprefixgs(var pblockptr: prefixrecgs);
  632.       inline $200AF4, $E100B022, $8F, '_toolErr';
  633.  
  634.     procedure getrefinfogs(var pblockptr: refinforecgs);
  635.       inline $2039F4, $E100B022, $8F, '_toolErr';
  636.  
  637.     procedure getrefnumgs(var pblockptr: getrefnumrecgs);
  638.       inline $2038F4, $E100B022, $8F, '_toolErr';
  639.  
  640.     procedure getstdrefnumgs(var pblockptr: stdrefnumrecgs);
  641.       inline $2037F4, $E100B022, $8F, '_toolErr';
  642.  
  643.     procedure getsysprefsgs(var pblockptr: sysprefsrecgs);
  644.       inline $200FF4, $E100B022, $8F, '_toolErr';
  645.  
  646.     procedure getversiongs(var pblockptr: versionrecgs);
  647.       inline $202AF4, $E100B022, $8F, '_toolErr';
  648.  
  649.     procedure judgenamegs(var pblockptr: judgenamerecgs);
  650.       inline $F4, $2007, $22, $E100B0, $8F, '_toolErr';
  651.  
  652.     procedure newlinegs(var pblockptr: newlinerecgs);
  653.       inline $2011F4, $E100B022, $8F, '_toolErr';
  654.  
  655.     procedure nullgs(var pblockptr: intptr);
  656.       inline $200DF4, $E100B022, $8F, '_toolErr';
  657.  
  658.     procedure opengs(var pblockptr: openrecgs);
  659.       inline $2010F4, $E100B022, $8F, '_toolErr';
  660.  
  661.     procedure osshutdowngs(var pblockptr: osshutdownrecgs);
  662.       inline $2003F4, $E100B022, $8F, '_toolErr';
  663.  
  664.     procedure quitgs(var pblockptr: quitrecgs);
  665.       inline $2029F4, $E100B022, $8F, '_toolErr';
  666.  
  667.     procedure readgs(var pblockptr: iorecgs);
  668.       inline $2012F4, $E100B022, $8F, '_toolErr';
  669.  
  670.     procedure resetcachegs(var pblockptr: intptr);
  671.       inline $2026F4, $E100B022, $8F, '_toolErr';
  672.  
  673.     procedure sessionstatusgs(var pblockptr: sessionstatusrecgs);
  674.       inline $201FF4, $E100B022, $8F, '_toolErr';
  675.  
  676.     procedure seteofgs(var pblockptr: setpositionrecgs);
  677.       inline $2018F4, $E100B022, $8F, '_toolErr';
  678.  
  679.     procedure setfileinfogs(var pblockptr: fileinforecgs);
  680.       inline $2005F4, $E100B022, $8F, '_toolErr';
  681.  
  682.     procedure setlevelgs(var pblockptr: levelrecgs);
  683.       inline $201AF4, $E100B022, $8F, '_toolErr';
  684.  
  685.     procedure setmarkgs(var pblockptr: setpositionrecgs);
  686.       inline $2016F4, $E100B022, $8F, '_toolErr';
  687.  
  688.     procedure setprefixgs(var pblockptr: prefixrecgs);
  689.       inline $2009F4, $E100B022, $8F, '_toolErr';
  690.  
  691.     procedure setstdrefnumgs(var pblockptr: stdrefnumrecgs);
  692.       inline $203AF4, $E100B022, $8F, '_toolErr';
  693.  
  694.     procedure setsysprefsgs(var pblockptr: sysprefsrecgs);
  695.       inline $200CF4, $E100B022, $8F, '_toolErr';
  696.  
  697.     procedure unbindintgs(var pblockptr: interruptrecgs);
  698.       inline $2032F4, $E100B022, $8F, '_toolErr';
  699.  
  700.     procedure volumegs(var pblockptr: volumerecgs);
  701.       inline $2008F4, $E100B022, $8F, '_toolErr';
  702.  
  703.     procedure writegs(var pblockptr: iorecgs);
  704.       inline $2013F4, $E100B022, $8F, '_toolErr';
  705.  
  706.   implementation
  707. end.
  708.